ടൈപ്പ്സ്ക്രിപ്റ്റിലൂടെ Node.js ഫയൽ പ്രവർത്തനങ്ങൾ ശക്തിപ്പെടുത്തുക. ടൈപ്പ് സുരക്ഷ, പിശക് കൈകാര്യം ചെയ്യൽ, ആഗോള ടീമുകൾക്കുള്ള മികച്ച സമ്പ്രദായങ്ങൾ എന്നിവയിൽ ഊന്നൽ നൽകി സിൻക്രണസ്, അസിൻക്രണസ്, സ്ട്രീം-അടിസ്ഥാന FS രീതികൾ ഈ സമഗ്ര ഗൈഡ് വിശദീകരിക്കുന്നു.
ടൈപ്പ്സ്ക്രിപ്റ്റ് ഫയൽ സിസ്റ്റം മാസ്റ്ററി: ആഗോള ഡെവലപ്പർമാർക്കായി ടൈപ്പ് സേഫ്റ്റിയോടെയുള്ള Node.js ഫയൽ പ്രവർത്തനങ്ങൾ
ആധുനിക സോഫ്റ്റ്‌വെയർ വികസനത്തിന്റെ വിശാലമായ ലോകത്ത്, അളക്കാവുന്ന സെർവർ-സൈഡ് ആപ്ലിക്കേഷനുകൾ, കമാൻഡ്-ലൈൻ ടൂളുകൾ എന്നിവയും അതിലേറെയും നിർമ്മിക്കുന്നതിനുള്ള ശക്തമായ റൺടൈമായി Node.js നിലകൊള്ളുന്നു. പല Node.js ആപ്ലിക്കേഷനുകളിലും ഫയൽ സിസ്റ്റവുമായി സംവദിക്കുന്നത് ഒരു അടിസ്ഥാനപരമായ കാര്യമാണ് – ഫയലുകളും ഡയറക്ടറികളും വായിക്കുക, എഴുതുക, ഉണ്ടാക്കുക, നിയന്ത്രിക്കുക എന്നിവയാണവ. ഈ പ്രവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യാനുള്ള സൗകര്യം JavaScript നൽകുമ്പോൾ, സ്റ്റാറ്റിക് ടൈപ്പ്-ചെക്കിംഗ്, മെച്ചപ്പെട്ട ടൂളിംഗ്, ആത്യന്തികമായി നിങ്ങളുടെ ഫയൽ സിസ്റ്റം കോഡിന് കൂടുതൽ വിശ്വാസ്യതയും പരിപാലനക്ഷമതയും നൽകിക്കൊണ്ട് TypeScript ഈ അനുഭവത്തെ കൂടുതൽ ഉയർത്തുന്നു.
Node.js ഫയൽ പ്രവർത്തനങ്ങൾ ടൈപ്പ്സ്ക്രിപ്റ്റ് നൽകുന്ന കരുത്തോടെ പഠിക്കാൻ ആഗ്രഹിക്കുന്ന, സാംസ്കാരികപരമായ പശ്ചാത്തലമോ ഭൂമിശാസ്ത്രപരമായ സ്ഥാനമോ പരിഗണിക്കാതെ, ആഗോള ഡെവലപ്പർമാർക്കുവേണ്ടിയാണ് ഈ സമഗ്ര ഗൈഡ് തയ്യാറാക്കിയിരിക്കുന്നത്. ഞങ്ങൾ അടിസ്ഥാനപരമായ `fs` മൊഡ്യൂൾ പരിശോധിക്കുകയും, അതിന്റെ വിവിധ സിൻക്രണസ്, അസിൻക്രണസ് രീതികൾ കണ്ടെത്തുകയും, ആധുനിക പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള API-കൾ പഠിക്കുകയും, ടൈപ്പ്സ്ക്രിപ്റ്റിന്റെ ടൈപ്പ് സിസ്റ്റം എങ്ങനെ സാധാരണ പിശകുകൾ ഗണ്യമായി കുറയ്ക്കാനും നിങ്ങളുടെ കോഡിന്റെ വ്യക്തത വർദ്ധിപ്പിക്കാനും സഹായിക്കുമെന്ന് കണ്ടെത്തുകയും ചെയ്യും.
അടിസ്ഥാനശില: Node.js ഫയൽ സിസ്റ്റം (`fs`) മനസ്സിലാക്കൽ
സ്റ്റാൻഡേർഡ് POSIX ഫംഗ്ഷനുകളെ മാതൃകയാക്കിയ ഒരു രീതിയിൽ ഫയൽ സിസ്റ്റവുമായി സംവദിക്കുന്നതിനുള്ള ഒരു API Node.js `fs` മൊഡ്യൂൾ നൽകുന്നു. അടിസ്ഥാന ഫയൽ റീഡുകൾക്കും റൈറ്റുകൾക്കും പുറമെ, സങ്കീർണ്ണമായ ഡയറക്ടറി കൃത്രിമങ്ങളും ഫയൽ വാച്ചിംഗും ഉൾപ്പെടെ നിരവധി രീതികൾ ഇത് വാഗ്ദാനം ചെയ്യുന്നു. പരമ്പരാഗതമായി, ഈ പ്രവർത്തനങ്ങൾ കോൾബാക്കുകൾ ഉപയോഗിച്ചാണ് കൈകാര്യം ചെയ്തിരുന്നത്, ഇത് സങ്കീർണ്ണമായ സാഹചര്യങ്ങളിൽ കുപ്രസിദ്ധമായ "callback hell" ലേക്ക് നയിച്ചു. Node.js-ന്റെ വികാസത്തോടെ, പ്രോമിസുകളും `async/await` ഉം അസിൻക്രണസ് പ്രവർത്തനങ്ങൾക്കുള്ള മികച്ച പാറ്റേണുകളായി ഉയർന്നുവന്നിട്ടുണ്ട്, ഇത് കോഡിനെ കൂടുതൽ വായിക്കാനും കൈകാര്യം ചെയ്യാനും എളുപ്പമാക്കുന്നു.
ഫയൽ സിസ്റ്റം പ്രവർത്തനങ്ങൾക്ക് ടൈപ്പ്സ്ക്രിപ്റ്റ് എന്തിന്?
Node.js-ന്റെ `fs` മൊഡ്യൂൾ സാധാരണ JavaScript-ൽ മികച്ച രീതിയിൽ പ്രവർത്തിക്കുമെങ്കിലും, ടൈപ്പ്സ്ക്രിപ്റ്റ് സംയോജിപ്പിക്കുന്നത് നിരവധി ആകർഷകമായ നേട്ടങ്ങൾ നൽകുന്നു:
- ടൈപ്പ് സുരക്ഷ: തെറ്റായ ആർഗ്യുമെന്റ് തരങ്ങൾ, ഇല്ലാത്ത പാരാമീറ്ററുകൾ, അല്ലെങ്കിൽ പ്രതീക്ഷിക്കാത്ത റിട്ടേൺ മൂല്യങ്ങൾ എന്നിവ പോലുള്ള സാധാരണ പിശകുകൾ നിങ്ങളുടെ കോഡ് പ്രവർത്തിക്കുന്നതിന് മുമ്പ് തന്നെ കംപൈൽ സമയത്ത് കണ്ടെത്തുന്നു. വിവിധ ഫയൽ എൻകോഡിംഗുകൾ, ഫ്ലാഗുകൾ, `Buffer` ഒബ്ജക്റ്റുകൾ എന്നിവ കൈകാര്യം ചെയ്യുമ്പോൾ ഇത് വളരെ വിലപ്പെട്ടതാണ്.
- മെച്ചപ്പെട്ട വായിക്കാനുള്ള കഴിവ്: വ്യക്തമായ ടൈപ്പ് വ്യാഖ്യാനങ്ങൾ ഒരു ഫംഗ്ഷൻ ഏത് തരത്തിലുള്ള ഡാറ്റയാണ് പ്രതീക്ഷിക്കുന്നതെന്നും അത് എന്താണ് തിരികെ നൽകുന്നതെന്നും വ്യക്തമാക്കുന്നു, ഇത് വിവിധ ടീമുകളിലെ ഡെവലപ്പർമാർക്ക് കോഡ് മനസ്സിലാക്കുന്നത് മെച്ചപ്പെടുത്തുന്നു.
- മികച്ച ടൂളിംഗ് & ഓട്ടോകംപ്ലീഷൻ: IDE-കൾ (VS Code പോലെ) ടൈപ്പ്സ്ക്രിപ്റ്റിന്റെ ടൈപ്പ് നിർവചനങ്ങൾ ഉപയോഗിച്ച് ബുദ്ധിപരമായ ഓട്ടോകംപ്ലീഷൻ, പാരാമീറ്റർ സൂചനകൾ, ഇൻലൈൻ ഡോക്യുമെന്റേഷൻ എന്നിവ നൽകുന്നു, ഇത് ഉൽപ്പാദനക്ഷമത ഗണ്യമായി വർദ്ധിപ്പിക്കുന്നു.
- റിഫാക്റ്ററിംഗ് വിശ്വാസം: നിങ്ങൾ ഒരു ഇന്റർഫേസ് അല്ലെങ്കിൽ ഒരു ഫംഗ്ഷൻ സിഗ്നേച്ചർ മാറ്റുമ്പോൾ, ടൈപ്പ്സ്ക്രിപ്റ്റ് ബാധിച്ച എല്ലാ മേഖലകളും ഉടനടി അടയാളപ്പെടുത്തുന്നു, ഇത് വലിയ തോതിലുള്ള റിഫാക്റ്ററിംഗ് പിശകുകൾ കുറയ്ക്കുന്നു.
- ആഗോള സ്ഥിരത: അന്താരാഷ്ട്ര ഡെവലപ്‌മെന്റ് ടീമുകൾക്കിടയിൽ സ്ഥിരമായ കോഡിംഗ് ശൈലിയും ഡാറ്റാ ഘടനകളെക്കുറിച്ചുള്ള ധാരണയും ഉറപ്പാക്കുന്നു, ഇത് അവ്യക്തത കുറയ്ക്കുന്നു.
സിൻക്രണസ് vs. അസിൻക്രണസ് പ്രവർത്തനങ്ങൾ: ഒരു ആഗോള കാഴ്ചപ്പാട്
സിൻക്രണസ്, അസിൻക്രണസ് പ്രവർത്തനങ്ങൾ തമ്മിലുള്ള വ്യത്യാസം മനസ്സിലാക്കുന്നത് വളരെ പ്രധാനമാണ്, പ്രത്യേകിച്ചും പ്രകടനവും പ്രതികരണശേഷിയും പരമപ്രധാനമായ ആഗോള വിന്യാസത്തിനായി ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുമ്പോൾ. മിക്ക `fs` മൊഡ്യൂൾ ഫംഗ്ഷനുകളും സിൻക്രണസ്, അസിൻക്രണസ് രൂപങ്ങളിൽ വരുന്നു. ഒരു പൊതു നിയമം എന്ന നിലയിൽ, Node.js സെർവറിന്റെ പ്രതികരണശേഷി നിലനിർത്തുന്നതിന് ആവശ്യമായ നോൺ-ബ്ലോക്കിംഗ് I/O പ്രവർത്തനങ്ങൾക്ക് അസിൻക്രണസ് രീതികളാണ് ഇഷ്ടപ്പെടുന്നത്.
- അസിൻക്രണസ് (നോൺ-ബ്ലോക്കിംഗ്): ഈ രീതികൾ അവയുടെ അവസാന ആർഗ്യുമെന്റായി ഒരു കോൾബാക്ക് ഫംഗ്ഷൻ സ്വീകരിക്കുകയോ ഒരു `Promise` തിരികെ നൽകുകയോ ചെയ്യുന്നു. അവ ഫയൽ സിസ്റ്റം പ്രവർത്തനം ആരംഭിക്കുകയും ഉടനടി മടങ്ങുകയും ചെയ്യുന്നു, മറ്റ് കോഡിന് പ്രവർത്തിക്കാൻ അനുവദിക്കുന്നു. പ്രവർത്തനം പൂർത്തിയാകുമ്പോൾ, കോൾബാക്ക് വിളിക്കപ്പെടും (അല്ലെങ്കിൽ Promise പരിഹരിക്കപ്പെടുകയോ നിരസിക്കപ്പെടുകയോ ചെയ്യും). ലോകമെമ്പാടുമുള്ള ഉപയോക്താക്കളിൽ നിന്ന് ഒരേ സമയം നിരവധി അഭ്യർത്ഥനകൾ കൈകാര്യം ചെയ്യുന്ന സെർവർ ആപ്ലിക്കേഷനുകൾക്ക് ഇത് അനുയോജ്യമാണ്, കാരണം ഒരു ഫയൽ പ്രവർത്തനം പൂർത്തിയാക്കാൻ കാത്തിരിക്കുമ്പോൾ സെർവർ തടസ്സപ്പെടുന്നത് ഇത് തടയുന്നു.
- സിൻക്രണസ് (ബ്ലോക്കിംഗ്): ഈ രീതികൾ പ്രവർത്തനം പൂർണ്ണമായി ചെയ്തതിനു ശേഷം മാത്രമേ തിരികെ നൽകൂ. കോഡ് ചെയ്യാൻ ഇത് ലളിതമാണെങ്കിലും, അവ Node.js ഇവന്റ് ലൂപ്പിനെ തടയുന്നു, ഫയൽ സിസ്റ്റം പ്രവർത്തനം പൂർത്തിയാകുന്നതുവരെ മറ്റ് കോഡിനും പ്രവർത്തിക്കാൻ കഴിയില്ല. ഇത് കാര്യമായ പ്രകടന തടസ്സങ്ങളിലേക്കും പ്രതികരണമില്ലാത്ത ആപ്ലിക്കേഷനുകളിലേക്കും നയിച്ചേക്കാം, പ്രത്യേകിച്ചും ഉയർന്ന ട്രാഫിക്കുള്ള ചുറ്റുപാടുകളിൽ. ആപ്ലിക്കേഷൻ സ്റ്റാർട്ടപ്പ് ലോജിക്കിനോ ബ്ലോക്കിംഗ് സ്വീകാര്യമായ ലളിതമായ സ്ക്രിപ്റ്റുകൾക്കോ മാത്രം അവ കുറച്ച് മാത്രം ഉപയോഗിക്കുക.
ടൈപ്പ്സ്ക്രിപ്റ്റിലെ പ്രധാന ഫയൽ പ്രവർത്തന തരങ്ങൾ
സാധാരണ ഫയൽ സിസ്റ്റം പ്രവർത്തനങ്ങളോടുകൂടിയ ടൈപ്പ്സ്ക്രിപ്റ്റിന്റെ പ്രായോഗിക ഉപയോഗത്തിലേക്ക് നമുക്ക് കടക്കാം. Node.js-നായുള്ള ബിൽറ്റ്-ഇൻ ടൈപ്പ് നിർവചനങ്ങൾ ഞങ്ങൾ ഉപയോഗിക്കും, ഇത് സാധാരണയായി `@types/node` പാക്കേജിലൂടെ ലഭ്യമാണ്.
ആരംഭിക്കുന്നതിന്, നിങ്ങളുടെ പ്രോജക്റ്റിൽ ടൈപ്പ്സ്ക്രിപ്റ്റും Node.js ടൈപ്പുകളും ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക:
npm install typescript @types/node --save-dev
നിങ്ങളുടെ `tsconfig.json` ഉചിതമായി കോൺഫിഗർ ചെയ്യണം, ഉദാഹരണത്തിന്:
{
"compilerOptions": {
"target": "es2020",
"module": "commonjs",
"outDir": "./dist",
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true
},
"include": ["src/**/*"]
}
ഫയലുകൾ വായിക്കുക: `readFile`, `readFileSync`, കൂടാതെ Promises API
ഫയലുകളിൽ നിന്ന് ഉള്ളടക്കം വായിക്കുന്നത് ഒരു അടിസ്ഥാനപരമായ പ്രവർത്തനമാണ്. ഫയൽ പാതകൾ, എൻകോഡിംഗുകൾ, സാധ്യതയുള്ള പിശകുകൾ എന്നിവ നിങ്ങൾ ശരിയായി കൈകാര്യം ചെയ്യുന്നുവെന്ന് ടൈപ്പ്സ്ക്രിപ്റ്റ് ഉറപ്പാക്കുന്നു.
അസിൻക്രണസ് ഫയൽ റീഡ് (കോൾബാക്ക് അടിസ്ഥാനമാക്കിയത്)
അസിൻക്രണസ് ഫയൽ റീഡിംഗിനുള്ള പ്രധാന ഫംഗ്ഷനാണ് `fs.readFile`. ഇത് പാത, ഒരു ഓപ്ഷണൽ എൻകോഡിംഗ്, ഒരു കോൾബാക്ക് ഫംഗ്ഷൻ എന്നിവ സ്വീകരിക്കുന്നു. കോൾബാക്കിന്റെ ആർഗ്യുമെന്റുകൾ ശരിയായി ടൈപ്പ് ചെയ്തിട്ടുണ്ടെന്ന് (`Error | null`, `Buffer | string`) ടൈപ്പ്സ്ക്രിപ്റ്റ് ഉറപ്പാക്കുന്നു.
import * as fs from 'fs';
const filePath: string = 'data/example.txt';
fs.readFile(filePath, 'utf8', (err: NodeJS.ErrnoException | null, data: string) => {
if (err) {
// അന്താരാഷ്ട്ര ഡീബഗ്ഗിംഗിനായി പിശക് രേഖപ്പെടുത്തുക, ഉദാഹരണത്തിന്, 'ഫയൽ കണ്ടെത്തിയില്ല'
console.error(`ഫയൽ വായിക്കുന്നതിൽ പിശക് '${filePath}': ${err.message}`);
return;
}
// 'utf8' എൻകോഡിംഗ് അനുസരിച്ച് ഇത് ഒരു സ്ട്രിംഗ് ആണെന്ന് ഉറപ്പാക്കി ഫയൽ ഉള്ളടക്കം പ്രോസസ്സ് ചെയ്യുക
console.log(`ഫയൽ ഉള്ളടക്കം (${filePath}):\n${data}`);
});
// ഉദാഹരണം: ബൈനറി ഡാറ്റ വായിക്കുന്നു (എൻകോഡിംഗ് വ്യക്തമാക്കിയിട്ടില്ല)
const binaryFilePath: string = 'data/image.png';
fs.readFile(binaryFilePath, (err: NodeJS.ErrnoException | null, data: Buffer) => {
if (err) {
console.error(`ബൈനറി ഫയൽ വായിക്കുന്നതിൽ പിശക് '${binaryFilePath}': ${err.message}`);
return;
}
// 'data' ഇവിടെ ഒരു Buffer ആണ്, കൂടുതൽ പ്രോസസ്സിംഗിനായി തയ്യാറാണ് (ഉദാഹരണത്തിന്, ഒരു ക്ലയന്റിലേക്ക് സ്ട്രീം ചെയ്യുന്നു)
console.log(`${binaryFilePath} ൽ നിന്ന് ${data.byteLength} ബൈറ്റുകൾ വായിച്ചു`);
});
സിൻക്രണസ് ഫയൽ റീഡ്
`fs.readFileSync` ഇവന്റ് ലൂപ്പിനെ തടയുന്നു. ഒരു എൻകോഡിംഗ് നൽകിയിട്ടുണ്ടോ എന്നതിനെ ആശ്രയിച്ച് അതിന്റെ റിട്ടേൺ ടൈപ്പ് `Buffer` അല്ലെങ്കിൽ `string` ആണ്. ടൈപ്പ്സ്ക്രിപ്റ്റ് ഇത് ശരിയായി അനുമാനിക്കുന്നു.
import * as fs from 'fs';
const syncFilePath: string = 'data/sync_example.txt';
try {
const content: string = fs.readFileSync(syncFilePath, 'utf8');
console.log(`സിൻക്രണസ് റീഡ് ഉള്ളടക്കം (${syncFilePath}):\n${content}`);
} catch (error: any) {
console.error(`'${syncFilePath}' നായുള്ള സിൻക്രണസ് റീഡ് പിശക്: ${error.message}`);
}
പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള ഫയൽ റീഡ് (`fs/promises`)
ആധുനിക `fs/promises` API ഒരു വൃത്തിയുള്ള, പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള ഇന്റർഫേസ് വാഗ്ദാനം ചെയ്യുന്നു, ഇത് അസിൻക്രണസ് പ്രവർത്തനങ്ങൾക്ക് വളരെ ശുപാർശ ചെയ്യപ്പെടുന്നു. ടൈപ്പ്സ്ക്രിപ്റ്റ് ഇവിടെ മികച്ചതാണ്, പ്രത്യേകിച്ചും `async/await` ഉപയോഗിച്ച്.
import * as fsPromises from 'fs/promises';
async function readTextFile(path: string): Promise<void> {
try {
// 'utf8' നൽകിയിട്ടുണ്ടെങ്കിൽ fsPromises.readFile റിട്ടേൺ ടൈപ്പ് string ആയി അനുമാനിക്കുന്നു
const content: string = await fsPromises.readFile(path, { encoding: 'utf8' });
console.log(`പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള റീഡ് ഉള്ളടക്കം (${path}):\n${content}`);
} catch (error: any) {
console.error(`'${path}' നായുള്ള പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള റീഡ് പിശക്: ${error.message}`);
}
}
async function readBinaryFile(path: string): Promise<void> {
try {
// എൻകോഡിംഗ് നൽകിയിട്ടില്ലെങ്കിൽ fsPromises.readFile റിട്ടേൺ ടൈപ്പ് Buffer ആയി അനുമാനിക്കുന്നു
const buffer: Buffer = await fsPromises.readFile(path);
console.log(`പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള ബൈനറി ഉള്ളടക്കം (${path}): ${buffer.byteLength} ബൈറ്റുകൾ`);
} catch (error: any) {
console.error(`'${path}' നായുള്ള പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള ബൈനറി പിശക്: ${error.message}`);
}
}
// ഡെമോൺസ്ട്രേഷനായി ഡമ്മി ഫയലുകൾ ഉണ്ടാക്കുക (ഓപ്ഷണൽ, പ്രാദേശിക പരിശോധനയ്ക്ക്)
async function setupFiles() {
await fsPromises.mkdir('data', { recursive: true });
await fsPromises.writeFile('data/example.txt', 'Hello from TypeScript FS!');
await fsPromises.writeFile('data/sync_example.txt', 'Synchronous content.');
// ബൈനറിക്കായി, ഞങ്ങൾ ഒരു ചെറിയ ബഫർ ഉണ്ടാക്കുന്നു
await fsPromises.writeFile('data/image.png', Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]));
}
setupFiles().then(() => {
readTextFile('data/example.txt');
readTextFile('non_existent_file.txt'); // പിശക് കൈകാര്യം ചെയ്യുന്നത് കാണിക്കുന്നു
readBinaryFile('data/image.png');
}).catch(err => console.error('സജ്ജീകരണ പിശക്:', err));
ഫയലുകൾ എഴുതുക: `writeFile`, `writeFileSync`, കൂടാതെ Flags
ഫയലുകളിലേക്ക് ഡാറ്റ എഴുതുന്നത് ഒരുപോലെ നിർണായകമാണ്. ഫയൽ പാതകൾ, ഡാറ്റ തരങ്ങൾ (string അല്ലെങ്കിൽ Buffer), എൻകോഡിംഗ്, ഫയൽ ഓപ്പൺ ഫ്ലാഗുകൾ എന്നിവ കൈകാര്യം ചെയ്യാൻ ടൈപ്പ്സ്ക്രിപ്റ്റ് സഹായിക്കുന്നു.
അസിൻക്രണസ് ഫയൽ റൈറ്റ്
ഫയലിലേക്ക് ഡാറ്റ എഴുതാൻ `fs.writeFile` ഉപയോഗിക്കുന്നു, ഫയൽ നിലവിലുണ്ടെങ്കിൽ അത് സ്ഥിരമായി മാറ്റിസ്ഥാപിക്കുന്നു. `flags` ഉപയോഗിച്ച് ഈ സ്വഭാവം നിയന്ത്രിക്കാനാകും.
import * as fs from 'fs';
const outputFilePath: string = 'data/output.txt';
const fileContent: string = 'ടൈപ്പ്സ്ക്രിപ്റ്റ് എഴുതിയ പുതിയ ഉള്ളടക്കമാണിത്.';
fs.writeFile(outputFilePath, fileContent, 'utf8', (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`ഫയൽ '${outputFilePath}' എഴുതുന്നതിൽ പിശക്: ${err.message}`);
return;
}
console.log(`ഫയൽ '${outputFilePath}' വിജയകരമായി എഴുതി.`);
});
// Buffer ഡാറ്റ ഉപയോഗിച്ചുള്ള ഉദാഹരണം
const bufferContent: Buffer = Buffer.from('ബൈനറി ഡാറ്റയുടെ ഉദാഹരണം');
const binaryOutputFilePath: string = 'data/binary_output.bin';
fs.writeFile(binaryOutputFilePath, bufferContent, (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`ബൈനറി ഫയൽ '${binaryOutputFilePath}' എഴുതുന്നതിൽ പിശക്: ${err.message}`);
return;
}
console.log(`ബൈനറി ഫയൽ '${binaryOutputFilePath}' വിജയകരമായി എഴുതി.`);
});
സിൻക്രണസ് ഫയൽ റൈറ്റ്
എഴുത്ത് പ്രവർത്തനം പൂർത്തിയാകുന്നത് വരെ `fs.writeFileSync` ഇവന്റ് ലൂപ്പിനെ തടയുന്നു.
import * as fs from 'fs';
const syncOutputFilePath: string = 'data/sync_output.txt';
try {
fs.writeFileSync(syncOutputFilePath, 'സിൻക്രണസ് ആയി എഴുതിയ ഉള്ളടക്കം.', 'utf8');
console.log(`ഫയൽ '${syncOutputFilePath}' സിൻക്രണസ് ആയി എഴുതി.`);
} catch (error: any) {
console.error(`'${syncOutputFilePath}' നായുള്ള സിൻക്രണസ് എഴുത്ത് പിശക്: ${error.message}`);
}
പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള ഫയൽ റൈറ്റ് (`fs/promises`)
`async/await` ഉം `fs/promises` ഉം ഉപയോഗിച്ചുള്ള ആധുനിക സമീപനം അസിൻക്രണസ് എഴുത്തുകൾ കൈകാര്യം ചെയ്യാൻ പലപ്പോഴും കൂടുതൽ വൃത്തി നൽകുന്നു.
import * as fsPromises from 'fs/promises';
import { constants as fsConstants } from 'fs'; // ഫ്ലാഗുകൾക്കായി
async function writeDataToFile(path: string, data: string | Buffer): Promise<void> {
try {
await fsPromises.writeFile(path, data, { encoding: 'utf8' });
console.log(`പ്രോമിസുകൾ ഉപയോഗിച്ച് ഫയൽ '${path}' വിജയകരമായി എഴുതി.`);
} catch (error: any) {
console.error(`പ്രോമിസുകൾ ഉപയോഗിച്ച് ഫയൽ '${path}' എഴുതുന്നതിൽ പിശക്: ${error.message}`);
}
}
// ഫ്ലാഗുകൾ ഉപയോഗിച്ച് ഓവർറൈറ്റ് vs. അപ്പൻഡ് കാണിക്കുന്നു
async function writeWithFlags(path: string, data: string, flag: string | number): Promise<void> {
try {
await fsPromises.writeFile(path, data, { flag: flag, encoding: 'utf8' });
console.log(`ഫയൽ '${path}' '${flag}' ഫ്ലാഗ് ഉപയോഗിച്ച് വിജയകരമായി എഴുതി.`);
} catch (error: any) {
console.error(`'${flag}' ഫ്ലാഗ് ഉപയോഗിച്ച് ഫയൽ '${path}' എഴുതുന്നതിൽ പിശക്: ${error.message}`);
}
}
(async () => {
// ആദ്യത്തെ എഴുത്ത് (ഉണ്ടാക്കുന്നു അല്ലെങ്കിൽ ഓവർറൈറ്റ് ചെയ്യുന്നു)
await writeDataToFile('data/flags_example.txt', 'ആദ്യ വരി.\n');
// നിലവിലുള്ള ഫയലിലേക്ക് ചേർക്കുക
await writeWithFlags('data/flags_example.txt', 'രണ്ടാമത്തെ വരി (ചേർത്തത്).\n', 'a');
// ഫയൽ നിലവിലില്ലെങ്കിൽ മാത്രം എഴുതുക (exclusive write)
await writeWithFlags('data/new_exclusive.txt', 'എക്സ്ക്ലൂസീവ് ഉള്ളടക്കം.\n', 'wx');
// ഇത് 'data/new_exclusive.txt' മുമ്പത്തെ റണ്ണിൽ നിന്ന് നിലവിലുണ്ടെങ്കിൽ പരാജയപ്പെടും
await writeWithFlags('data/new_exclusive.txt', 'എക്സ്ക്ലൂസീവ് ഉള്ളടക്കം ഓവർറൈറ്റ് ചെയ്യാനുള്ള ശ്രമം (ഫയൽ നിലവിലുണ്ടെങ്കിൽ പരാജയപ്പെടണം).\n', 'wx');
})();
പ്രധാന ഫ്ലാഗുകൾ:
- `'w'` (സ്ഥിരം): എഴുതുന്നതിനായി ഫയൽ തുറക്കുക. ഫയൽ ഉണ്ടാക്കുന്നു (നിലവിലില്ലെങ്കിൽ) അല്ലെങ്കിൽ ചെറുതാക്കുന്നു (നിലവിലുണ്ടെങ്കിൽ).
- `'w+'`: വായിക്കാനും എഴുതാനുമായി ഫയൽ തുറക്കുക. ഫയൽ ഉണ്ടാക്കുന്നു (നിലവിലില്ലെങ്കിൽ) അല്ലെങ്കിൽ ചെറുതാക്കുന്നു (നിലവിലുണ്ടെങ്കിൽ).
- `'a'` (ചേർക്കുക): ചേർക്കുന്നതിനായി ഫയൽ തുറക്കുക. ഫയൽ നിലവിലില്ലെങ്കിൽ ഉണ്ടാക്കുന്നു.
- `'a+'`: വായിക്കാനും ചേർക്കാനുമായി ഫയൽ തുറക്കുക. ഫയൽ നിലവിലില്ലെങ്കിൽ ഉണ്ടാക്കുന്നു.
- `'r'` (വായിക്കുക): വായിക്കുന്നതിനായി ഫയൽ തുറക്കുക. ഫയൽ നിലവിലില്ലെങ്കിൽ ഒരു എക്സെപ്ഷൻ സംഭവിക്കുന്നു.
- `'r+'`: വായിക്കാനും എഴുതാനുമായി ഫയൽ തുറക്കുക. ഫയൽ നിലവിലില്ലെങ്കിൽ ഒരു എക്സെപ്ഷൻ സംഭവിക്കുന്നു.
- `'wx'` (exclusive write): `'w'` പോലെ, പക്ഷേ പാത നിലവിലുണ്ടെങ്കിൽ പരാജയപ്പെടുന്നു.
- `'ax'` (exclusive append): `'a'` പോലെ, പക്ഷേ പാത നിലവിലുണ്ടെങ്കിൽ പരാജയപ്പെടുന്നു.
ഫയലുകളിലേക്ക് ചേർക്കുക: `appendFile`, `appendFileSync`
നിലവിലുള്ള ഒരു ഫയലിന്റെ ഉള്ളടക്കം മാറ്റിസ്ഥാപിക്കാതെ അതിന്റെ അവസാനം ഡാറ്റ ചേർക്കേണ്ടിവരുമ്പോൾ, `appendFile` ആണ് നിങ്ങളുടെ തിരഞ്ഞെടുപ്പ്. ലോഗിംഗ്, ഡാറ്റ ശേഖരണം, അല്ലെങ്കിൽ ഓഡിറ്റ് ട്രയലുകൾ എന്നിവയ്ക്ക് ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.
അസിൻക്രണസ് അപ്പൻഡ്
import * as fs from 'fs';
const logFilePath: string = 'data/app_logs.log';
function logMessage(message: string): void {
const timestamp: string = new Date().toISOString();
const logEntry: string = `${timestamp} - ${message}\n`;
fs.appendFile(logFilePath, logEntry, 'utf8', (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`ലോഗ് ഫയൽ '${logFilePath}' ലേക്ക് ചേർക്കുന്നതിൽ പിശക്: ${err.message}`);
return;
}
console.log(`സന്ദേശം '${logFilePath}' ലേക്ക് ലോഗ് ചെയ്തു.`);
});
}
logMessage('ഉപയോക്താവ് "Alice" ലോഗിൻ ചെയ്തു.');
setTimeout(() => logMessage('സിസ്റ്റം അപ്‌ഡേറ്റ് ആരംഭിച്ചു.'), 50);
logMessage('ഡാറ്റാബേസ് കണക്ഷൻ സ്ഥാപിച്ചു.');
സിൻക്രണസ് അപ്പൻഡ്
import * as fs from 'fs';
const syncLogFilePath: string = 'data/sync_app_logs.log';
function logMessageSync(message: string): void {
const timestamp: string = new Date().toISOString();
const logEntry: string = `${timestamp} - ${message}\n`;
try {
fs.appendFileSync(syncLogFilePath, logEntry, 'utf8');
console.log(`സന്ദേശം '${syncLogFilePath}' ലേക്ക് സിൻക്രണസ് ആയി ലോഗ് ചെയ്തു.`);
} catch (error: any) {
console.error(`ലോഗ് ഫയൽ '${syncLogFilePath}' ലേക്ക് സിൻക്രണസ് ആയി ചേർക്കുന്നതിൽ പിശക്: ${error.message}`);
}
}
logMessageSync('ആപ്ലിക്കേഷൻ ആരംഭിച്ചു.');
logMessageSync('കോൺഫിഗറേഷൻ ലോഡ് ചെയ്തു.');
പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള അപ്പൻഡ് (`fs/promises`)
import * as fsPromises from 'fs/promises';
const promiseLogFilePath: string = 'data/promise_app_logs.log';
async function logMessagePromise(message: string): Promise<void> {
const timestamp: string = new Date().toISOString();
const logEntry: string = `${timestamp} - ${message}\n`;
try {
await fsPromises.appendFile(promiseLogFilePath, logEntry, 'utf8');
console.log(`പ്രോമിസുകൾ ഉപയോഗിച്ച് സന്ദേശം '${promiseLogFilePath}' ലേക്ക് ലോഗ് ചെയ്തു.`);
} catch (error: any) {
console.error(`പ്രോമിസുകൾ ഉപയോഗിച്ച് ലോഗ് ഫയൽ '${promiseLogFilePath}' ലേക്ക് ചേർക്കുന്നതിൽ പിശക്: ${error.message}`);
}
}
(async () => {
await logMessagePromise('സർവീസ് ആരംഭിച്ചു.');
await logMessagePromise('ഡാറ്റാ പ്രോസസ്സിംഗ് ആരംഭിച്ചു.');
})();
ഫയലുകൾ ഇല്ലാതാക്കുക: `unlink`, `unlinkSync`
ഫയൽ സിസ്റ്റത്തിൽ നിന്ന് ഫയലുകൾ നീക്കം ചെയ്യുന്നു. നിങ്ങൾ ഒരു സാധുവായ പാത നൽകുന്നുവെന്നും പിശകുകൾ ശരിയായി കൈകാര്യം ചെയ്യുന്നുവെന്നും ടൈപ്പ്സ്ക്രിപ്റ്റ് ഉറപ്പാക്കാൻ സഹായിക്കുന്നു.
അസിൻക്രണസ് ഡിലീറ്റ്
import * as fs from 'fs';
const fileToDeletePath: string = 'data/temp_to_delete.txt';
// ആദ്യം, ഡിലീഷൻ ഡെമോയ്ക്കായി ഫയൽ നിലവിലുണ്ടെന്ന് ഉറപ്പാക്കുക
fs.writeFile(fileToDeletePath, 'താൽക്കാലിക ഉള്ളടക്കം.', 'utf8', (err) => {
if (err) {
console.error('ഡിലീഷൻ ഡെമോയ്ക്കായി ഫയൽ ഉണ്ടാക്കുന്നതിൽ പിശക്:', err);
return;
}
console.log(`ഫയൽ '${fileToDeletePath}' ഡിലീഷൻ ഡെമോയ്ക്കായി ഉണ്ടാക്കി.`);
fs.unlink(fileToDeletePath, (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`ഫയൽ '${fileToDeletePath}' ഡിലീറ്റ് ചെയ്യുന്നതിൽ പിശക്: ${err.message}`);
return;
}
console.log(`ഫയൽ '${fileToDeletePath}' വിജയകരമായി ഡിലീറ്റ് ചെയ്തു.`);
});
});
സിൻക്രണസ് ഡിലീറ്റ്
import * as fs from 'fs';
const syncFileToDeletePath: string = 'data/sync_temp_to_delete.txt';
try {
fs.writeFileSync(syncFileToDeletePath, 'സിൻക്രണസ് താൽക്കാലിക ഉള്ളടക്കം.', 'utf8');
console.log(`ഫയൽ '${syncFileToDeletePath}' ഉണ്ടാക്കി.`);
fs.unlinkSync(syncFileToDeletePath);
console.log(`ഫയൽ '${syncFileToDeletePath}' സിൻക്രണസ് ആയി ഡിലീറ്റ് ചെയ്തു.`);
} catch (error: any) {
console.error(`'${syncFileToDeletePath}' നായുള്ള സിൻക്രണസ് ഡിലീഷൻ പിശക്: ${error.message}`);
}
പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള ഡിലീറ്റ് (`fs/promises`)
import * as fsPromises from 'fs/promises';
const promiseFileToDeletePath: string = 'data/promise_temp_to_delete.txt';
async function deleteFile(path: string): Promise<void> {
try {
// ഡെമോൺസ്ട്രേഷൻ ആവശ്യങ്ങൾക്കായി ആദ്യം ഫയൽ ഉണ്ടാക്കുക
await fsPromises.writeFile(path, 'പ്രോമിസ് താൽക്കാലിക ഉള്ളടക്കം.', 'utf8');
console.log(`പ്രോമിസ് ഡിലീഷൻ ഡെമോയ്ക്കായി ഫയൽ '${path}' ഉണ്ടാക്കി.`);
await fsPromises.unlink(path);
console.log(`പ്രോമിസുകൾ ഉപയോഗിച്ച് ഫയൽ '${path}' വിജയകരമായി ഡിലീറ്റ് ചെയ്തു.`);
} catch (error: any) {
console.error(`പ്രോമിസുകൾ ഉപയോഗിച്ച് ഫയൽ '${path}' ഡിലീറ്റ് ചെയ്യുന്നതിൽ പിശക്: ${error.message}`);
}
}
deleteFile(promiseFileToDeletePath);
ഫയൽ നിലനിൽപ്പും അനുമതികളും പരിശോധിക്കുക: `existsSync`, `access`, `accessSync`
ഒരു ഫയലിൽ പ്രവർത്തിക്കുന്നതിന് മുമ്പ്, അത് നിലവിലുണ്ടോ അല്ലെങ്കിൽ നിലവിലെ പ്രോസസ്സിന് ആവശ്യമായ അനുമതികൾ ഉണ്ടോ എന്ന് പരിശോധിക്കേണ്ടതുണ്ട്. `mode` പാരാമീറ്ററിനായുള്ള ടൈപ്പുകൾ നൽകിക്കൊണ്ട് ടൈപ്പ്സ്ക്രിപ്റ്റ് സഹായിക്കുന്നു.
സിൻക്രണസ് നിലനിൽപ്പ് പരിശോധന
`fs.existsSync` ഒരു ലളിതമായ, സിൻക്രണസ് പരിശോധനയാണ്. ഇത് സൗകര്യപ്രദമാണെങ്കിലും, ഒരു റേസ് കണ്ടീഷൻ അപകടസാധ്യതയുണ്ട് (existsSync-നും തുടർന്നുള്ള ഒരു പ്രവർത്തനത്തിനും ഇടയിൽ ഒരു ഫയൽ ഇല്ലാതാക്കപ്പെടാം), അതിനാൽ നിർണായക പ്രവർത്തനങ്ങൾക്ക് `fs.access` ഉപയോഗിക്കുന്നതാണ് പലപ്പോഴും നല്ലത്.
import * as fs from 'fs';
const checkFilePath: string = 'data/example.txt';
if (fs.existsSync(checkFilePath)) {
console.log(`ഫയൽ '${checkFilePath}' നിലവിലുണ്ട്.`);
} else {
console.log(`ഫയൽ '${checkFilePath}' നിലവിലില്ല.`);
}
അസിൻക്രണസ് അനുമതി പരിശോധന (`fs.access`)
`fs.access` `path` ഉപയോഗിച്ച് വ്യക്തമാക്കിയ ഫയലിന്റെയോ ഡയറക്ടറിയുടെയോ ഉപയോക്താവിന്റെ അനുമതികൾ പരിശോധിക്കുന്നു. ഇത് അസിൻക്രണസ് ആണ് കൂടാതെ ഒരു `mode` ആർഗ്യുമെന്റ് സ്വീകരിക്കുന്നു (ഉദാഹരണത്തിന്, നിലനിൽപ്പിനായി `fs.constants.F_OK`, വായിക്കാൻ `R_OK`, എഴുതാൻ `W_OK`, എക്സിക്യൂട്ട് ചെയ്യാൻ `X_OK`).
import * as fs from 'fs';
import { constants } from 'fs';
const accessFilePath: string = 'data/example.txt';
fs.access(accessFilePath, constants.F_OK, (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`ഫയൽ '${accessFilePath}' നിലവിലില്ല അല്ലെങ്കിൽ ആക്സസ് നിരസിച്ചു.`);
return;
}
console.log(`ഫയൽ '${accessFilePath}' നിലവിലുണ്ട്.`);
});
fs.access(accessFilePath, constants.R_OK | constants.W_OK, (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`ഫയൽ '${accessFilePath}' വായിക്കാൻ/എഴുതാൻ കഴിയുന്നില്ല അല്ലെങ്കിൽ ആക്സസ് നിരസിച്ചു: ${err.message}`);
return;
}
console.log(`ഫയൽ '${accessFilePath}' വായിക്കാനും എഴുതാനും കഴിയുന്നതാണ്.`);
});
പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള അനുമതി പരിശോധന (`fs/promises`)
import * as fsPromises from 'fs/promises';
import { constants } from 'fs';
async function checkFilePermissions(path: string, mode: number): Promise<void> {
try {
await fsPromises.access(path, mode);
const modeDescription =
(mode === constants.F_OK ? 'നിലവിലുണ്ട്' : '') +
((mode & constants.R_OK) ? ' വായിക്കാവുന്നത്' : '') +
((mode & constants.W_OK) ? ' എഴുതാവുന്നത്' : '') +
((mode & constants.X_OK) ? ' പ്രവർത്തിപ്പിക്കാവുന്നത്' : '');
console.log(`ഫയൽ '${path}' ${modeDescription.trim()} ആണ്.`);
} catch (error: any) {
console.error(`ഫയൽ '${path}' ആക്സസ് പിശക്: ${error.message}`);
}
}
(async () => {
await checkFilePermissions('data/example.txt', constants.F_OK); // നിലനിൽപ്പ് പരിശോധിക്കുക
await checkFilePermissions('data/example.txt', constants.R_OK | constants.W_OK); // വായിക്കാനുള്ള/എഴുതാനുള്ള അനുമതി പരിശോധിക്കുക
await checkFilePermissions('data/non_existent_file.txt', constants.F_OK); // പിശക് വരണം
})();
ഫയൽ വിവരങ്ങൾ നേടുക: `stat`, `statSync`, `fs.Stats`
`fs.stat` ഫംഗ്ഷനുകൾ ഒരു ഫയലിന്റെയോ ഡയറക്ടറിയുടെയോ വലുപ്പം, ഉണ്ടാക്കിയ തീയതി, മാറ്റം വരുത്തിയ തീയതി, അനുമതികൾ എന്നിവ പോലുള്ള വിശദമായ വിവരങ്ങൾ നൽകുന്നു. ടൈപ്പ്സ്ക്രിപ്റ്റിന്റെ `fs.Stats` ഇന്റർഫേസ് ഈ ഡാറ്റയെ വളരെ ഘടനാപരവും വിശ്വസനീയവുമാക്കുന്നു.
അസിൻക്രണസ് സ്റ്റാറ്റ്
import * as fs from 'fs';
import { Stats } from 'fs';
const statFilePath: string = 'data/example.txt';
fs.stat(statFilePath, (err: NodeJS.ErrnoException | null, stats: Stats) => {
if (err) {
console.error(`'${statFilePath}' നായുള്ള സ്റ്റാറ്റുകൾ നേടുന്നതിൽ പിശക്: ${err.message}`);
return;
}
console.log(`'${statFilePath}' നായുള്ള സ്റ്റാറ്റുകൾ:`);
console.log(` ഫയൽ ആണോ: ${stats.isFile()}`);
console.log(` ഡയറക്ടറി ആണോ: ${stats.isDirectory()}`);
console.log(` വലുപ്പം: ${stats.size} ബൈറ്റുകൾ`);
console.log(` ഉണ്ടാക്കിയ സമയം: ${stats.birthtime.toISOString()}`);
console.log(` അവസാനം മാറ്റം വരുത്തിയത്: ${stats.mtime.toISOString()}`);
});
പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള സ്റ്റാറ്റ് (`fs/promises`)
import * as fsPromises from 'fs/promises';
import { Stats } from 'fs'; // ഇപ്പോഴും 'fs' മൊഡ്യൂളിന്റെ Stats ഇന്റർഫേസ് ഉപയോഗിക്കുക
async function getFileStats(path: string): Promise<void> {
try {
const stats: Stats = await fsPromises.stat(path);
console.log(`'${path}' നായുള്ള പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള സ്റ്റാറ്റുകൾ:`);
console.log(` ഫയൽ ആണോ: ${stats.isFile()}`);
console.log(` ഡയറക്ടറി ആണോ: ${stats.isDirectory()}`);
console.log(` വലുപ്പം: ${stats.size} ബൈറ്റുകൾ`);
console.log(` ഉണ്ടാക്കിയ സമയം: ${stats.birthtime.toISOString()}`);
console.log(` അവസാനം മാറ്റം വരുത്തിയത്: ${stats.mtime.toISOString()}`);
} catch (error: any) {
console.error(`പ്രോമിസുകൾ ഉപയോഗിച്ച് '${path}' നായുള്ള സ്റ്റാറ്റുകൾ നേടുന്നതിൽ പിശക്: ${error.message}`);
}
}
getFileStats('data/example.txt');
getFileStats('data/non_existent_dir_or_file'); // പിശക് വരണം
ടൈപ്പ്സ്ക്രിപ്റ്റ് ഉപയോഗിച്ചുള്ള ഡയറക്ടറി പ്രവർത്തനങ്ങൾ
ഫയലുകൾ ഓർഗനൈസ് ചെയ്യാനും, ആപ്ലിക്കേഷൻ-നിർദ്ദിഷ്ട സ്റ്റോറേജ് ഉണ്ടാക്കാനും, താൽക്കാലിക ഡാറ്റ കൈകാര്യം ചെയ്യാനും ഡയറക്ടറികൾ നിയന്ത്രിക്കുന്നത് ഒരു സാധാരണ ആവശ്യകതയാണ്. ടൈപ്പ്സ്ക്രിപ്റ്റ് ഈ പ്രവർത്തനങ്ങൾക്ക് കരുത്തുറ്റ ടൈപ്പിംഗ് നൽകുന്നു.
ഡയറക്ടറികൾ ഉണ്ടാക്കുക: `mkdir`, `mkdirSync`
പുതിയ ഡയറക്ടറികൾ ഉണ്ടാക്കാൻ `fs.mkdir` ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു. `recursive` ഓപ്ഷൻ, മാതൃ ഡയറക്ടറികൾ നിലവിലില്ലെങ്കിൽ അവയെ ഉണ്ടാക്കാൻ അവിശ്വസനീയമാംവിധം ഉപയോഗപ്രദമാണ്, Unix പോലുള്ള സിസ്റ്റങ്ങളിലെ `mkdir -p` ന്റെ സ്വഭാവം അനുകരിക്കുന്നു.
അസിൻക്രണസ് ഡയറക്ടറി നിർമ്മാണം
import * as fs from 'fs';
const newDirPath: string = 'data/new_directory';
const recursiveDirPath: string = 'data/nested/path/to/create';
// ഒരു ഡയറക്ടറി ഉണ്ടാക്കുക
fs.mkdir(newDirPath, (err: NodeJS.ErrnoException | null) => {
if (err) {
// ഡയറക്ടറി നിലവിലുണ്ടെങ്കിൽ EEXIST പിശക് അവഗണിക്കുക
if (err.code === 'EEXIST') {
console.log(`ഡയറക്ടറി '${newDirPath}' നിലവിലുണ്ട്.`);
} else {
console.error(`ഡയറക്ടറി '${newDirPath}' ഉണ്ടാക്കുന്നതിൽ പിശക്: ${err.message}`);
}
return;
}
console.log(`ഡയറക്ടറി '${newDirPath}' വിജയകരമായി ഉണ്ടാക്കി.`);
});
// നെസ്റ്റഡ് ഡയറക്ടറികൾ ആവർത്തിച്ച് ഉണ്ടാക്കുക
fs.mkdir(recursiveDirPath, { recursive: true }, (err: NodeJS.ErrnoException | null) => {
if (err) {
if (err.code === 'EEXIST') {
console.log(`ഡയറക്ടറി '${recursiveDirPath}' നിലവിലുണ്ട്.`);
} else {
console.error(`ആവർത്തിച്ചുള്ള ഡയറക്ടറി '${recursiveDirPath}' ഉണ്ടാക്കുന്നതിൽ പിശക്: ${err.message}`);
}
return;
}
console.log(`ആവർത്തിച്ചുള്ള ഡയറക്ടറികൾ '${recursiveDirPath}' വിജയകരമായി ഉണ്ടാക്കി.`);
});
പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള ഡയറക്ടറി നിർമ്മാണം (`fs/promises`)
import * as fsPromises from 'fs/promises';
async function createDirectory(path: string, recursive: boolean = false): Promise<void> {
try {
await fsPromises.mkdir(path, { recursive: recursive });
console.log(`ഡയറക്ടറി '${path}' വിജയകരമായി ഉണ്ടാക്കി (recursive: ${recursive}).`);
} catch (error: any) {
// recursive false ഉം ഡയറക്ടറി നിലവിലുണ്ടെങ്കിൽ Node.js 'EEXIST' പിശക് നൽകും
if (error.code === 'EEXIST' && !recursive) {
console.log(`ഡയറക്ടറി '${path}' നിലവിലുണ്ട്.`);
} else if (error.code === 'EEXIST' && recursive) {
// recursive: true ആണെങ്കിൽ, EEXIST ഒരു പിശകല്ല, അത് നിലവിലുണ്ടെന്ന് മാത്രം അർത്ഥമാക്കുന്നു
console.log(`ആവർത്തിച്ചുള്ള പാത '${path}' നിലവിലുണ്ട്.`);
} else {
console.error(`പ്രോമിസുകൾ ഉപയോഗിച്ച് ഡയറക്ടറി '${path}' ഉണ്ടാക്കുന്നതിൽ പിശക്: ${error.message}`);
}
}
}
(async () => {
await createDirectory('data/promise_dir');
await createDirectory('data/promise_dir'); // EEXIST കൈകാര്യം ചെയ്യുന്നത് കാണിക്കുക
await createDirectory('data/promise_nested/path', true);
})();
ഡയറക്ടറി ഉള്ളടക്കം വായിക്കുക: `readdir`, `readdirSync`, `fs.Dirent`
നൽകിയിട്ടുള്ള ഒരു ഡയറക്ടറിയിലെ ഫയലുകളും സബ്ഡയറക്ടറികളും ലിസ്റ്റ് ചെയ്യാൻ, നിങ്ങൾ `fs.readdir` ഉപയോഗിക്കുന്നു. `withFileTypes` ഓപ്ഷൻ ഒരു ആധുനിക കൂട്ടിച്ചേർക്കലാണ്, അത് `fs.Dirent` ഒബ്ജക്റ്റുകൾ തിരികെ നൽകുന്നു, ഓരോ എൻട്രിയും `stat` ചെയ്യാതെ തന്നെ കൂടുതൽ വിശദമായ വിവരങ്ങൾ നേരിട്ട് നൽകുന്നു.
അസിൻക്രണസ് ഡയറക്ടറി റീഡ്
import * as fs from 'fs';
const readDirPath: string = 'data';
fs.readdir(readDirPath, (err: NodeJS.ErrnoException | null, files: string[]) => {
if (err) {
console.error(`ഡയറക്ടറി '${readDirPath}' വായിക്കുന്നതിൽ പിശക്: ${err.message}`);
return;
}
console.log(`ഡയറക്ടറി '${readDirPath}' ന്റെ ഉള്ളടക്കം:`);
files.forEach(file => {
console.log(` - ${file}`);
});
});
// `withFileTypes` ഓപ്ഷൻ ഉപയോഗിച്ച്
fs.readdir(readDirPath, { withFileTypes: true }, (err: NodeJS.ErrnoException | null, dirents: fs.Dirent[]) => {
if (err) {
console.error(`ഫയൽ തരങ്ങൾ സഹിതം ഡയറക്ടറി '${readDirPath}' വായിക്കുന്നതിൽ പിശക്: ${err.message}`);
return;
}
console.log(`ഡയറക്ടറി '${readDirPath}' ന്റെ ഉള്ളടക്കം (തരങ്ങൾ സഹിതം):`);
dirents.forEach(dirent => {
const type: string = dirent.isFile() ? 'ഫയൽ' : dirent.isDirectory() ? 'ഡയറക്ടറി' : 'മറ്റുള്ളവ';
console.log(` - ${dirent.name} (${type})`);
});
});
പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള ഡയറക്ടറി റീഡ് (`fs/promises`)
import * as fsPromises from 'fs/promises';
import { Dirent } from 'fs'; // ഇപ്പോഴും 'fs' മൊഡ്യൂളിന്റെ Dirent ഇന്റർഫേസ് ഉപയോഗിക്കുക
async function listDirectoryContents(path: string): Promise<void> {
try {
const files: string[] = await fsPromises.readdir(path);
console.log(`'${path}' ഡയറക്ടറിയുടെ പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള ഉള്ളടക്കം:`);
files.forEach(file => console.log(` - ${file}`));
} catch (error: any) {
console.error(`പ്രോമിസുകൾ ഉപയോഗിച്ച് ഡയറക്ടറി '${path}' ലിസ്റ്റ് ചെയ്യുന്നതിൽ പിശക്: ${error.message}`);
}
}
async function listDirectoryContentsWithTypes(path: string): Promise<void> {
try {
const dirents: Dirent[] = await fsPromises.readdir(path, { withFileTypes: true });
console.log(`'${path}' ഡയറക്ടറിയുടെ പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള ഉള്ളടക്കം (തരങ്ങൾ സഹിതം):`);
dirents.forEach(dirent => {
const type: string = dirent.isFile() ? 'ഫയൽ' : dirent.isDirectory() ? 'ഡയറക്ടറി' : 'മറ്റുള്ളവ';
console.log(` - ${dirent.name} (${type})`);
});
} catch (error: any) {
console.error(`പ്രോമിസുകൾ ഉപയോഗിച്ച് '${path}' ഡയറക്ടറി തരങ്ങൾ സഹിതം ലിസ്റ്റ് ചെയ്യുന്നതിൽ പിശക്: ${error.message}`);
}
}
(async () => {
// ഡെമോയ്ക്കായി 'data' ഡയറക്ടറിയും ചില ഫയലുകളും നിലവിലുണ്ടെന്ന് ഉറപ്പാക്കുക
await fsPromises.mkdir('data', { recursive: true });
await fsPromises.writeFile('data/temp_file1.txt', 'ഉള്ളടക്കം 1');
await fsPromises.mkdir('data/sub_dir');
await fsPromises.writeFile('data/sub_dir/temp_file2.txt', 'ഉള്ളടക്കം 2');
await listDirectoryContents('data');
await listDirectoryContentsWithTypes('data');
await listDirectoryContents('non_existent_dir'); // പിശക് വരണം
})();
ഡയറക്ടറികൾ ഇല്ലാതാക്കുക: `rmdir` (deprecated), `rm`, `rmSync`
Node.js അതിന്റെ ഡയറക്ടറി ഡിലീഷൻ രീതികൾ വികസിപ്പിച്ചിട്ടുണ്ട്. ആവർത്തിച്ചുള്ള ഡിലീഷനുകൾക്കായി `fs.rmdir` ഇപ്പോൾ `fs.rm` നെ മാറ്റിസ്ഥാപിച്ചിട്ടുണ്ട്, ഇത് കൂടുതൽ കരുത്തുറ്റതും സ്ഥിരതയുള്ളതുമായ ഒരു API വാഗ്ദാനം ചെയ്യുന്നു.
അസിൻക്രണസ് ഡയറക്ടറി ഡിലീഷൻ (`fs.rm`)
`fs.rm` ഫംഗ്ഷൻ (Node.js 14.14.0 മുതൽ ലഭ്യമാണ്) ഫയലുകളും ഡയറക്ടറികളും നീക്കം ചെയ്യാനുള്ള ശുപാർശ ചെയ്യുന്ന മാർഗ്ഗമാണ്. `recursive: true` ഓപ്ഷൻ, ശൂന്യമല്ലാത്ത ഡയറക്ടറികൾ ഇല്ലാതാക്കാൻ നിർണായകമാണ്.
import * as fs from 'fs';
const dirToDeletePath: string = 'data/dir_to_delete';
const nestedDirToDeletePath: string = 'data/nested_dir/sub';
// സജ്ജീകരണം: ആവർത്തിച്ചുള്ള ഡിലീഷൻ ഡെമോയ്ക്കായി ഒരു ഫയൽ ഉള്ള ഒരു ഡയറക്ടറി ഉണ്ടാക്കുക
fs.mkdir(nestedDirToDeletePath, { recursive: true }, (err) => {
if (err && err.code !== 'EEXIST') {
console.error('ഡെമോയ്ക്കായി നെസ്റ്റഡ് ഡയറക്ടറി ഉണ്ടാക്കുന്നതിൽ പിശക്:', err);
return;
}
fs.writeFile(`${nestedDirToDeletePath}/file_inside.txt`, 'കുറച്ച് ഉള്ളടക്കം', (err) => {
if (err) { console.error('നെസ്റ്റഡ് ഡയറക്ടറിക്കുള്ളിൽ ഫയൽ ഉണ്ടാക്കുന്നതിൽ പിശക്:', err); return; }
console.log(`ഡയറക്ടറി '${nestedDirToDeletePath}' ഉം ഫയലും ഡിലീഷൻ ഡെമോയ്ക്കായി ഉണ്ടാക്കി.`);
fs.rm(nestedDirToDeletePath, { recursive: true, force: true }, (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`ആവർത്തിച്ചുള്ള ഡയറക്ടറി '${nestedDirToDeletePath}' ഡിലീറ്റ് ചെയ്യുന്നതിൽ പിശക്: ${err.message}`);
return;
}
console.log(`ആവർത്തിച്ചുള്ള ഡയറക്ടറി '${nestedDirToDeletePath}' വിജയകരമായി ഡിലീറ്റ് ചെയ്തു.`);
});
});
});
// ശൂന്യമായ ഒരു ഡയറക്ടറി ഡിലീറ്റ് ചെയ്യുന്നു
fs.mkdir(dirToDeletePath, (err) => {
if (err && err.code !== 'EEXIST') {
console.error('ഡെമോയ്ക്കായി ശൂന്യമായ ഡയറക്ടറി ഉണ്ടാക്കുന്നതിൽ പിശക്:', err);
return;
}
console.log(`ഡയറക്ടറി '${dirToDeletePath}' ഡിലീഷൻ ഡെമോയ്ക്കായി ഉണ്ടാക്കി.`);
fs.rm(dirToDeletePath, { recursive: false }, (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`ശൂന്യമായ ഡയറക്ടറി '${dirToDeletePath}' ഡിലീറ്റ് ചെയ്യുന്നതിൽ പിശക്: ${err.message}`);
return;
}
console.log(`ശൂന്യമായ ഡയറക്ടറി '${dirToDeletePath}' വിജയകരമായി ഡിലീറ്റ് ചെയ്തു.`);
});
});
പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള ഡയറക്ടറി ഡിലീഷൻ (`fs/promises`)
import * as fsPromises from 'fs/promises';
async function deleteDirectory(path: string, recursive: boolean = false): Promise<void> {
try {
// ആവർത്തിച്ചുള്ള ഡിലീഷൻ പരിശോധനയ്ക്കായി ഒരു ഡമ്മി നെസ്റ്റഡ് ഘടന ഉണ്ടാക്കുക
if (recursive) {
await fsPromises.mkdir(`${path}/sub_dir`, { recursive: true });
await fsPromises.writeFile(`${path}/sub_dir/file.txt`, 'പരിശോധിക്കുക');
} else {
await fsPromises.mkdir(path, { recursive: true }); // മാതൃ ഡയറക്ടറി നിലവിലുണ്ടെന്ന് ഉറപ്പാക്കുക
}
console.log(`ഡിലീറ്റ് ചെയ്യുന്നതിനായി '${path}' ൽ ഡയറക്ടറി സജ്ജീകരണം പൂർത്തിയായി.`);
await fsPromises.rm(path, { recursive: recursive, force: true });
console.log(`ഡയറക്ടറി '${path}' വിജയകരമായി ഡിലീറ്റ് ചെയ്തു (recursive: ${recursive}).`);
} catch (error: any) {
console.error(`പ്രോമിസുകൾ ഉപയോഗിച്ച് ഡയറക്ടറി '${path}' ഡിലീറ്റ് ചെയ്യുന്നതിൽ പിശക്: ${error.message}`);
}
}
(async () => {
await deleteDirectory('data/promise_dir_to_delete', false); // ശൂന്യമായത് ഡിലീറ്റ് ചെയ്യുക
await deleteDirectory('data/promise_nested_dir_to_delete', true); // ശൂന്യമല്ലാത്തത് ഡിലീറ്റ് ചെയ്യുക
await deleteDirectory('data/non_existent_dir_to_delete'); // മര്യാദയോടെ കൈകാര്യം ചെയ്യണം
})();
ടൈപ്പ്സ്ക്രിപ്റ്റ് ഉപയോഗിച്ചുള്ള വിപുലമായ ഫയൽ സിസ്റ്റം ആശയങ്ങൾ
അടിസ്ഥാന റീഡ്/റൈറ്റ് പ്രവർത്തനങ്ങൾക്കപ്പുറം, വലിയ ഫയലുകൾ, തുടർച്ചയായ ഡാറ്റാ ഫ്ലോകൾ, ഫയൽ സിസ്റ്റത്തിന്റെ തത്സമയ നിരീക്ഷണം എന്നിവ കൈകാര്യം ചെയ്യാൻ Node.js ശക്തമായ സവിശേഷതകൾ വാഗ്ദാനം ചെയ്യുന്നു. ടൈപ്പ്സ്ക്രിപ്റ്റിന്റെ ടൈപ്പ് ഡിക്ലറേഷനുകൾ ഈ വിപുലമായ സാഹചര്യങ്ങളിലേക്കും നന്നായി വ്യാപിച്ച് കരുത്ത് ഉറപ്പാക്കുന്നു.
ഫയൽ ഡിസ്ക്രിപ്റ്ററുകളും സ്ട്രീമുകളും
വളരെ വലിയ ഫയലുകൾക്ക് അല്ലെങ്കിൽ ഫയൽ ആക്സസിൽ സൂക്ഷ്മമായ നിയന്ത്രണം ആവശ്യമുള്ളപ്പോൾ (ഉദാഹരണത്തിന്, ഒരു ഫയലിനുള്ളിലെ പ്രത്യേക സ്ഥാനങ്ങൾ), ഫയൽ ഡിസ്ക്രിപ്റ്ററുകളും സ്ട്രീമുകളും അത്യന്താപേക്ഷിതമാകുന്നു. ഒരു വലിയ അളവ് ഡാറ്റ ഒരുമിച്ച് മെമ്മറിയിലേക്ക് ലോഡ് ചെയ്യുന്നതിനു പകരം, ഭാഗങ്ങളായി വായിക്കാനോ എഴുതാനോ സ്ട്രീമുകൾ ഒരു കാര്യക്ഷമമായ മാർഗ്ഗം നൽകുന്നു, ഇത് സ്കേലബിൾ ആപ്ലിക്കേഷനുകൾക്കും ആഗോള സെർവറുകളിലെ കാര്യക്ഷമമായ റിസോഴ്സ് മാനേജ്മെന്റിനും നിർണായകമാണ്.
ഡിസ്ക്രിപ്റ്ററുകൾ ഉപയോഗിച്ച് ഫയലുകൾ തുറക്കുകയും അടയ്ക്കുകയും ചെയ്യുക (`fs.open`, `fs.close`)
ഒരു തുറന്ന ഫയലിന് ഓപ്പറേറ്റിംഗ് സിസ്റ്റം നൽകുന്ന ഒരു അദ്വിതീയ ഐഡന്റിഫയർ (ഒരു സംഖ്യ) ആണ് ഫയൽ ഡിസ്ക്രിപ്റ്റർ. ഒരു ഫയൽ ഡിസ്ക്രിപ്റ്റർ ലഭിക്കാൻ നിങ്ങൾക്ക് `fs.open` ഉപയോഗിക്കാം, തുടർന്ന് ആ ഡിസ്ക്രിപ്റ്റർ ഉപയോഗിച്ച് `fs.read` അല്ലെങ്കിൽ `fs.write` പോലുള്ള പ്രവർത്തനങ്ങൾ നടത്താം, ഒടുവിൽ അത് `fs.close` ചെയ്യാം.
import * as fs from 'fs';
import { promises as fsPromises } from 'fs';
import { constants } from 'fs';
const descriptorFilePath: string = 'data/descriptor_example.txt';
async function demonstrateFileDescriptorOperations(): Promise<void> {
let fileDescriptor: number | undefined;
try {
// വായിക്കുന്നതിനായി ഫയൽ നിലവിലുണ്ടെന്ന് ഉറപ്പാക്കുക, അല്ലെങ്കിൽ എഴുതുന്നതിനായി ഉണ്ടാക്കുക
await fsPromises.writeFile(descriptorFilePath, 'ഡിസ്ക്രിപ്റ്റർ വഴി വായിക്കാനും മാറ്റം വരുത്താനുമുള്ള ഉള്ളടക്കം.');
console.log(`ഫയൽ '${descriptorFilePath}' ഡിസ്ക്രിപ്റ്റർ ഡെമോയ്ക്കായി തയ്യാറാക്കി.`);
// വായിക്കാനും എഴുതാനുമായി ഫയൽ തുറക്കുക ('r+' flag)
// fsPromises.open ഒരു FileHandle ഒബ്ജക്റ്റ് തിരികെ നൽകുന്നു, അതിന് അതിന്റേതായ ഡിസ്ക്രിപ്റ്റർ ഉണ്ട്
const fileHandle = await fsPromises.open(descriptorFilePath, constants.O_RDWR); // O_RDWR വായിക്കാനും എഴുതാനുമുള്ളതാണ്
fileDescriptor = fileHandle.fd; // യഥാർത്ഥ ഫയൽ ഡിസ്ക്രിപ്റ്റർ നേടുക
console.log(`ഫയൽ ഡിസ്ക്രിപ്റ്റർ ഉപയോഗിച്ച് തുറന്നു: ${fileDescriptor}`);
// ഫയലിൽ നിന്ന് ഡാറ്റ വായിക്കുക
const buffer = Buffer.alloc(100);
const { bytesRead, buffer: readBuffer } = await fileHandle.read(buffer, 0, buffer.length, 0);
console.log(`ഡിസ്ക്രിപ്റ്ററിൽ നിന്ന് ${bytesRead} ബൈറ്റുകൾ വായിച്ചു: '${readBuffer.toString('utf8', 0, bytesRead)}'`);
// ഒരു പ്രത്യേക സ്ഥാനത്തേക്ക് ഡാറ്റ എഴുതുക (ഉദാഹരണത്തിന്, 'Content' നെ 'UPDATED' ഉപയോഗിച്ച് മാറ്റിയെഴുതുക)
const writeData = Buffer.from('UPDATED');
const { bytesWritten } = await fileHandle.write(writeData, 0, writeData.length, 0);
console.log(`${bytesWritten} ബൈറ്റുകൾ ഡിസ്ക്രിപ്റ്ററിലേക്ക് എഴുതി.`);
// മാറ്റങ്ങൾ സ്ഥിരീകരിക്കാൻ വീണ്ടും വായിക്കുക
const bufferAfterWrite = Buffer.alloc(100);
const { bytesRead: br2, buffer: readBuffer2 } = await fileHandle.read(bufferAfterWrite, 0, bufferAfterWrite.length, 0);
console.log(`എഴുതിയതിന് ശേഷമുള്ള ഉള്ളടക്കം: '${readBuffer2.toString('utf8', 0, br2)}'`);
await fileHandle.close();
console.log('ഫയൽ ഡിസ്ക്രിപ്റ്റർ അടച്ചു.');
} catch (error: any) {
console.error(`ഫയൽ ഡിസ്ക്രിപ്റ്റർ പ്രവർത്തനങ്ങളിൽ പിശക്: ${error.message}`);
} finally {
if (fileDescriptor !== undefined) {
// fileHandle.open ന് ശേഷം, fileHandle.close വിളിക്കുന്നതിന് മുമ്പ് ഒരു പിശക് സംഭവിക്കുന്ന സാഹചര്യങ്ങൾ ഈ 'finally' ബ്ലോക്ക് കൈകാര്യം ചെയ്യുന്നു,
// ഇത് വൃത്തിയാക്കൽ ഉറപ്പാക്കുന്നു.
// ഈ പ്രത്യേക async/await ഘടനയിൽ, fileHandle.close() സാധാരണയായി മതിയാകും
// fileHandle തന്നെ .close() വിളിക്കുന്നതിന് മുമ്പ് പരാജയപ്പെടുന്നില്ലെങ്കിൽ.
}
}
}
demonstrateFileDescriptorOperations();
ഫയൽ സ്ട്രീമുകൾ (`fs.createReadStream`, `fs.createWriteStream`)
വലിയ ഫയലുകൾ കാര്യക്ഷമമായി കൈകാര്യം ചെയ്യാൻ സ്ട്രീമുകൾ ശക്തമാണ്. `fs.createReadStream` ഉം `fs.createWriteStream` ഉം യഥാക്രമം `Readable` ഉം `Writable` ഉം സ്ട്രീമുകൾ തിരികെ നൽകുന്നു, അവ Node.js-ന്റെ സ്ട്രീമിംഗ് API-യുമായി തടസ്സമില്ലാതെ സംയോജിക്കുന്നു. ഈ സ്ട്രീം ഇവന്റുകൾക്ക് (ഉദാഹരണത്തിന്, `'data'`, `'end'`, `'error'`) ടൈപ്പ്സ്ക്രിപ്റ്റ് മികച്ച ടൈപ്പ് നിർവചനങ്ങൾ നൽകുന്നു.
import * as fs from 'fs';
const largeFilePath: string = 'data/large_file.txt';
const copiedFilePath: string = 'data/copied_file.txt';
// ഡെമോൺസ്ട്രേഷനായി ഒരു ഡമ്മി വലിയ ഫയൽ ഉണ്ടാക്കുക
function createLargeFile(path: string, sizeInMB: number): void {
const content: string = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. '; // 56 chars
const stream = fs.createWriteStream(path);
const totalChars = sizeInMB * 1024 * 1024; // MB നെ ബൈറ്റുകളാക്കി മാറ്റുക
const iterations = Math.ceil(totalChars / content.length);
for (let i = 0; i < iterations; i++) {
stream.write(content);
}
stream.end(() => console.log(`വലിയ ഫയൽ '${path}' (${sizeInMB}MB) ഉണ്ടാക്കി.`));
}
// ഡെമോൺസ്ട്രേഷനായി, ആദ്യം 'data' ഡയറക്ടറി നിലവിലുണ്ടെന്ന് ഉറപ്പാക്കുക
fs.mkdir('data', { recursive: true }, (err) => {
if (err && err.code !== 'EEXIST') {
console.error('ഡാറ്റാ ഡയറക്ടറി ഉണ്ടാക്കുന്നതിൽ പിശക്:', err);
return;
}
createLargeFile(largeFilePath, 1); // ഒരു 1MB ഫയൽ ഉണ്ടാക്കുക
});
// സ്ട്രീമുകൾ ഉപയോഗിച്ച് ഫയൽ പകർത്തുക
function copyFileWithStreams(source: string, destination: string): void {
const readStream = fs.createReadStream(source);
const writeStream = fs.createWriteStream(destination);
readStream.on('open', () => console.log(`'${source}' നായുള്ള സ്ട്രീം തുറന്നു വായിക്കുന്നു.`));
writeStream.on('open', () => console.log(`'${destination}' നായുള്ള സ്ട്രീം എഴുതുന്നതിനായി തുറന്നു.`));
// റീഡ് സ്ട്രീമിൽ നിന്ന് റൈറ്റ് സ്ട്രീമിലേക്ക് ഡാറ്റ പൈപ്പ് ചെയ്യുക
readStream.pipe(writeStream);
readStream.on('error', (err: Error) => {
console.error(`റീഡ് സ്ട്രീം പിശക്: ${err.message}`);
});
writeStream.on('error', (err: Error) => {
console.error(`റൈറ്റ് സ്ട്രീം പിശക്: ${err.message}`);
});
writeStream.on('finish', () => {
console.log(`ഫയൽ '${source}' സ്ട്രീമുകൾ ഉപയോഗിച്ച് വിജയകരമായി '${destination}' ലേക്ക് പകർത്തി.`);
// പകർത്തിയ ശേഷം ഡമ്മി വലിയ ഫയൽ വൃത്തിയാക്കുക
fs.unlink(largeFilePath, (err) => {
if (err) console.error('വലിയ ഫയൽ ഡിലീറ്റ് ചെയ്യുന്നതിൽ പിശക്:', err);
else console.log(`വലിയ ഫയൽ '${largeFilePath}' ഡിലീറ്റ് ചെയ്തു.`);
});
});
}
// പകർത്തി തുടങ്ങുന്നതിന് മുമ്പ് വലിയ ഫയൽ ഉണ്ടാകാൻ കുറച്ച് സമയം കാത്തിരിക്കുക
setTimeout(() => {
copyFileWithStreams(largeFilePath, copiedFilePath);
}, 1000);
മാറ്റങ്ങൾ നിരീക്ഷിക്കുക: `fs.watch`, `fs.watchFile`
ഡെവലപ്‌മെന്റ് സെർവറുകൾ ഹോട്ട്-റീലോഡ് ചെയ്യുക, ബിൽഡ് പ്രോസസ്സുകൾ, അല്ലെങ്കിൽ ഫയൽ സിസ്റ്റത്തിന്റെ തത്സമയ നിരീക്ഷണം എന്നിവ പോലുള്ള കാര്യങ്ങൾക്ക് ഫയൽ സിസ്റ്റത്തിലെ മാറ്റങ്ങൾ നിരീക്ഷിക്കുന്നത് വളരെ പ്രധാനമാണ്. Node.js ഇതിനായി രണ്ട് പ്രധാന രീതികൾ നൽകുന്നു: `fs.watch` ഉം `fs.watchFile` ഉം. ഇവന്റ് തരങ്ങളും ലിസണർ പാരാമീറ്ററുകളും ശരിയായി കൈകാര്യം ചെയ്യുന്നുവെന്ന് ടൈപ്പ്സ്ക്രിപ്റ്റ് ഉറപ്പാക്കുന്നു.
`fs.watch`: ഇവന്റ് അടിസ്ഥാനമാക്കിയുള്ള ഫയൽ സിസ്റ്റം നിരീക്ഷണം
`fs.watch` സാധാരണയായി കൂടുതൽ കാര്യക്ഷമമാണ്, കാരണം ഇത് പലപ്പോഴും ഓപ്പറേറ്റിംഗ് സിസ്റ്റം-ലെവൽ അറിയിപ്പുകൾ ഉപയോഗിക്കുന്നു (ഉദാഹരണത്തിന്, Linux-ൽ `inotify`, macOS-ൽ `kqueue`, Windows-ൽ `ReadDirectoryChangesW`). പ്രത്യേക ഫയലുകളോ ഡയറക്ടറികളോ മാറ്റങ്ങൾ, ഡിലീഷനുകൾ, അല്ലെങ്കിൽ പേരുമാറ്റങ്ങൾ എന്നിവയ്ക്കായി നിരീക്ഷിക്കാൻ ഇത് അനുയോജ്യമാണ്.
import * as fs from 'fs';
const watchedFilePath: string = 'data/watched_file.txt';
const watchedDirPath: string = 'data/watched_dir';
// നിരീക്ഷിക്കുന്നതിനായി ഫയലുകളും/ഡയറക്ടറികളും നിലവിലുണ്ടെന്ന് ഉറപ്പാക്കുക
fs.writeFileSync(watchedFilePath, 'ആദ്യത്തെ ഉള്ളടക്കം.');
fs.mkdirSync(watchedDirPath, { recursive: true });
console.log(`'${watchedFilePath}' ലെ മാറ്റങ്ങൾ നിരീക്ഷിക്കുന്നു...`);
const fileWatcher = fs.watch(watchedFilePath, (eventType: string, filename: string | Buffer | null) => {
const fname = typeof filename === 'string' ? filename : filename?.toString('utf8');
console.log(`ഫയൽ '${fname || 'ലഭ്യമല്ല'}' ഇവന്റ്: ${eventType}`);
if (eventType === 'change') {
console.log('ഫയൽ ഉള്ളടക്കം മാറിയിരിക്കാം.');
}
// ഒരു യഥാർത്ഥ ആപ്ലിക്കേഷനിൽ, നിങ്ങൾ ഇവിടെ ഫയൽ വായിക്കുകയോ ഒരു റീബിൽഡ് ട്രിഗർ ചെയ്യുകയോ ചെയ്യാം
});
console.log(`ഡയറക്ടറി '${watchedDirPath}' ലെ മാറ്റങ്ങൾ നിരീക്ഷിക്കുന്നു...`);
const dirWatcher = fs.watch(watchedDirPath, (eventType: string, filename: string | Buffer | null) => {
const fname = typeof filename === 'string' ? filename : filename?.toString('utf8');
console.log(`ഡയറക്ടറി '${watchedDirPath}' ഇവന്റ്: '${fname || 'ലഭ്യമല്ല'}' ൽ ${eventType}`);
});
fileWatcher.on('error', (err: Error) => console.error(`ഫയൽ വാച്ചർ പിശക്: ${err.message}`));
dirWatcher.on('error', (err: Error) => console.error(`ഡയറക്ടറി വാച്ചർ പിശക്: ${err.message}`));
// ഒരു കാലതാമസത്തിനുശേഷം മാറ്റങ്ങൾ അനുകരിക്കുക
setTimeout(() => {
console.log('\n--- മാറ്റങ്ങൾ അനുകരിക്കുന്നു ---');
fs.appendFileSync(watchedFilePath, '\nപുതിയ വരി ചേർത്തു.');
fs.writeFileSync(`${watchedDirPath}/new_file.txt`, 'ഉള്ളടക്കം.');
fs.unlinkSync(`${watchedDirPath}/new_file.txt`); // ഡിലീഷൻ കൂടി പരിശോധിക്കുക
setTimeout(() => {
fileWatcher.close();
dirWatcher.close();
console.log('\nവാച്ചറുകൾ അടച്ചു.');
// താൽക്കാലിക ഫയലുകളും/ഡയറക്ടറികളും വൃത്തിയാക്കുക
fs.unlinkSync(watchedFilePath);
fs.rmSync(watchedDirPath, { recursive: true, force: true });
}, 2000);
}, 1000);
`fs.watch` നെക്കുറിച്ചുള്ള കുറിപ്പ്: എല്ലാ പ്ലാറ്റ്‌ഫോമുകളിലും എല്ലാത്തരം ഇവന്റുകൾക്കും ഇത് എല്ലായ്പ്പോഴും വിശ്വസനീയമല്ല (ഉദാഹരണത്തിന്, ഫയൽ പേരുമാറ്റങ്ങൾ ഡിലീഷനുകളും ക്രിയേഷനുകളുമായി റിപ്പോർട്ട് ചെയ്യപ്പെട്ടേക്കാം). ശക്തമായ ക്രോസ്-പ്ലാറ്റ്ഫോം ഫയൽ നിരീക്ഷണത്തിനായി, `chokidar` പോലുള്ള ലൈബ്രറികൾ പരിഗണിക്കുക, ഇത് പലപ്പോഴും `fs.watch` അടിയിൽ ഉപയോഗിക്കുന്നുവെങ്കിലും നോർമലൈസേഷനും ഫാൾബാക്ക് മെക്കാനിസങ്ങളും ചേർക്കുന്നു.
`fs.watchFile`: പോളിംഗ് അടിസ്ഥാനമാക്കിയുള്ള ഫയൽ നിരീക്ഷണം
`fs.watchFile` മാറ്റങ്ങൾ കണ്ടെത്താൻ പോളിംഗ് (ഫയലിന്റെ `stat` ഡാറ്റ ഇടയ്ക്കിടെ പരിശോധിക്കുന്നത്) ഉപയോഗിക്കുന്നു. ഇത് കാര്യക്ഷമത കുറവാണെങ്കിലും വിവിധ ഫയൽ സിസ്റ്റങ്ങളിലും നെറ്റ്‌വർക്ക് ഡ്രൈവുകളിലും കൂടുതൽ സ്ഥിരതയുള്ളതാണ്. `fs.watch` വിശ്വസനീയമല്ലാത്ത ചുറ്റുപാടുകളിൽ (ഉദാഹരണത്തിന്, NFS ഷെയറുകൾ) ഇത് കൂടുതൽ അനുയോജ്യമാണ്.
import * as fs from 'fs';
import { Stats } from 'fs';
const pollFilePath: string = 'data/polled_file.txt';
fs.writeFileSync(pollFilePath, 'ആദ്യത്തെ പോൾ ചെയ്ത ഉള്ളടക്കം.');
console.log(`'${pollFilePath}' ലെ മാറ്റങ്ങൾ പോൾ ചെയ്യുന്നു...`);
fs.watchFile(pollFilePath, { interval: 1000 }, (curr: Stats, prev: Stats) => {
// 'curr' ഉം 'prev' ഉം fs.Stats ഒബ്ജക്റ്റുകൾ ആണെന്ന് ടൈപ്പ്സ്ക്രിപ്റ്റ് ഉറപ്പാക്കുന്നു
if (curr.mtimeMs !== prev.mtimeMs) {
console.log(`ഫയൽ '${pollFilePath}' മാറ്റം വരുത്തി (mtime മാറി). പുതിയ വലുപ്പം: ${curr.size} ബൈറ്റുകൾ.`);
}
});
setTimeout(() => {
console.log('\n--- പോൾ ചെയ്ത ഫയൽ മാറ്റം അനുകരിക്കുന്നു ---');
fs.appendFileSync(pollFilePath, '\nപോൾ ചെയ്ത ഫയലിലേക്ക് മറ്റൊരു വരി ചേർത്തു.');
setTimeout(() => {
fs.unwatchFile(pollFilePath);
console.log(`\n'${pollFilePath}' നിരീക്ഷിക്കുന്നത് നിർത്തി.`);
fs.unlinkSync(pollFilePath);
}, 2000);
}, 1500);
ആഗോള സാഹചര്യങ്ങളിൽ പിശക് കൈകാര്യം ചെയ്യലും മികച്ച സമ്പ്രദായങ്ങളും
ഏതൊരു പ്രൊഡക്ഷൻ-റെഡി ആപ്ലിക്കേഷനും, പ്രത്യേകിച്ചും ഫയൽ സിസ്റ്റവുമായി സംവദിക്കുന്ന ഒന്നിനും, കരുത്തുറ്റ പിശക് കൈകാര്യം ചെയ്യൽ അത്യന്താപേക്ഷിതമാണ്. ഫയൽ പ്രവർത്തനങ്ങൾ നിരവധി കാരണങ്ങളാൽ പരാജയപ്പെട്ടേക്കാം: അനുമതി പ്രശ്നങ്ങൾ, ഡിസ്ക് നിറഞ്ഞുപോയ പിശകുകൾ, ഫയൽ കണ്ടെത്തിയില്ല, I/O പിശകുകൾ, നെറ്റ്‌വർക്ക് പ്രശ്നങ്ങൾ (നെറ്റ്‌വർക്ക്-മൗണ്ട് ചെയ്ത ഡ്രൈവുകൾക്ക്), അല്ലെങ്കിൽ ഒരേസമയം ആക്സസ് ചെയ്യുന്നതിലുള്ള തർക്കങ്ങൾ. ടൈപ്പ്സ്ക്രിപ്റ്റ് ടൈപ്പ് സംബന്ധമായ പ്രശ്നങ്ങൾ കണ്ടെത്താൻ നിങ്ങളെ സഹായിക്കുന്നു, എന്നാൽ റൺടൈം പിശകുകൾക്ക് ഇപ്പോഴും ശ്രദ്ധാപൂർവ്വമായ മാനേജ്മെന്റ് ആവശ്യമാണ്.
പിശക് കൈകാര്യം ചെയ്യൽ തന്ത്രങ്ങൾ
- സിൻക്രണസ് പ്രവർത്തനങ്ങൾ: `fs.xxxSync` കോളുകൾ എല്ലായ്പ്പോഴും `try...catch` ബ്ലോക്കുകളിൽ ഉൾപ്പെടുത്തുക. ഈ രീതികൾ നേരിട്ട് പിശകുകൾ എറിയുന്നു.
- അസിൻക്രണസ് കോൾബാക്കുകൾ: ഒരു `fs` കോൾബാക്കിലേക്കുള്ള ആദ്യത്തെ ആർഗ്യുമെന്റ് എല്ലായ്പ്പോഴും `err: NodeJS.ErrnoException | null` ആണ്. ഈ `err` ഒബ്ജക്റ്റിനായി എല്ലായ്പ്പോഴും ആദ്യം പരിശോധിക്കുക.
- പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ളത് (`fs/promises`): നിരസനങ്ങൾ കൈകാര്യം ചെയ്യാൻ `await` ഉപയോഗിച്ച് `try...catch` അല്ലെങ്കിൽ `.then()` ചെയിനുകൾക്കൊപ്പം `.catch()` ഉപയോഗിക്കുക.
നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ പിശക് ഫീഡ്ബാക്ക് ഉപയോക്താവിനെ നേരിട്ട് ബാധിക്കുന്നതാണെങ്കിൽ പിശക് ലോഗിംഗ് ഫോർമാറ്റുകൾ സ്റ്റാൻഡേർഡ് ചെയ്യുന്നത് നല്ലതാണ്, കൂടാതെ പിശക് സന്ദേശങ്ങൾക്ക് അന്താരാഷ്ട്രവൽക്കരണം (i18n) പരിഗണിക്കുക.
import * as fs from 'fs';
import { promises as fsPromises } from 'fs';
import * as path from 'path';
const problematicPath = path.join('non_existent_dir', 'file.txt');
// സിൻക്രണസ് പിശക് കൈകാര്യം ചെയ്യൽ
try {
fs.readFileSync(problematicPath, 'utf8');
} catch (error: any) {
console.error(`സിൻക്രണസ് പിശക്: ${error.code} - ${error.message} (പാത: ${problematicPath})`);
}
// കോൾബാക്ക് അടിസ്ഥാനമാക്കിയുള്ള പിശക് കൈകാര്യം ചെയ്യൽ
fs.readFile(problematicPath, 'utf8', (err, data) => {
if (err) {
console.error(`കോൾബാക്ക് പിശക്: ${err.code} - ${err.message} (പാത: ${problematicPath})`);
return;
}
// ... ഡാറ്റാ പ്രോസസ്സ് ചെയ്യുക
});
// പ്രോമിസ് അടിസ്ഥാനമാക്കിയുള്ള പിശക് കൈകാര്യം ചെയ്യൽ
async function safeReadFile(filePath: string): Promise<string | null> {
try {
return await fsPromises.readFile(filePath, 'utf8');
} catch (error: any) {
console.error(`പ്രോമിസ് പിശക്: ${error.code} - ${error.message} (പാത: ${filePath})`);
return null;
}
}
safeReadFile(problematicPath).then(content => {
if (content !== null) {
// ... ഉള്ളടക്കം പ്രോസസ്സ് ചെയ്യുക
}
});
റിസോഴ്സ് മാനേജ്മെന്റ്: ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ അടയ്ക്കുക
`fs.open` (അല്ലെങ്കിൽ `fsPromises.open`) ഉപയോഗിച്ച് പ്രവർത്തിക്കുമ്പോൾ, പ്രവർത്തനങ്ങൾ പൂർത്തിയാകുമ്പോൾ, പിശകുകൾ സംഭവിച്ചാൽ പോലും, ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ എല്ലായ്പ്പോഴും `fs.close` (അല്ലെങ്കിൽ `fileHandle.close()`) ഉപയോഗിച്ച് അടച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുന്നത് വളരെ പ്രധാനമാണ്. അങ്ങനെ ചെയ്യുന്നതിൽ പരാജയപ്പെടുന്നത് റിസോഴ്സ് ലീക്കുകളിലേക്കും, ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന്റെ തുറന്ന ഫയൽ പരിധിയിൽ എത്താനോ, നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ക്രാഷ് ആകാനോ മറ്റ് പ്രോസസ്സുകളെ ബാധിക്കാനോ സാധ്യതയുണ്ട്.
`FileHandle` ഒബ്ജക്റ്റുകളുള്ള `fs/promises` API ഇത് പൊതുവെ ലളിതമാക്കുന്നു, കാരണം `fileHandle.close()` ഈ ആവശ്യത്തിനായി പ്രത്യേകം രൂപകൽപ്പന ചെയ്തതാണ്, കൂടാതെ `FileHandle` ഇൻസ്റ്റൻസുകൾ `Disposable` ആണ് (Node.js 18.11.0+ ഉം ടൈപ്പ്സ്ക്രിപ്റ്റ് 5.2+ ഉം ഉപയോഗിക്കുകയാണെങ്കിൽ).
പാത മാനേജ്മെന്റും ക്രോസ്-പ്ലാറ്റ്ഫോം അനുയോജ്യതയും
ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾക്കിടയിൽ ഫയൽ പാതകൾ ഗണ്യമായി വ്യത്യാസപ്പെടുന്നു (ഉദാഹരണത്തിന്, Windows-ൽ `\`, Unix പോലുള്ള സിസ്റ്റങ്ങളിൽ `/`). ക്രോസ്-പ്ലാറ്റ്ഫോം അനുയോജ്യമായ രീതിയിൽ ഫയൽ പാതകൾ നിർമ്മിക്കുന്നതിനും പാഴ്‌സ് ചെയ്യുന്നതിനും Node.js `path` മൊഡ്യൂൾ ഒഴിച്ചുകൂടാനാവാത്തതാണ്, ഇത് ആഗോള വിന്യാസങ്ങൾക്ക് അത്യന്താപേക്ഷിതമാണ്.
- `path.join(...paths)`: നൽകിയിട്ടുള്ള എല്ലാ പാത ഭാഗങ്ങളെയും ഒരുമിച്ച് ചേർക്കുന്നു, ഫലമായുണ്ടാകുന്ന പാതയെ സാധാരണ നിലയിലാക്കുന്നു.
- `path.resolve(...paths)`: പാതകളുടെ അല്ലെങ്കിൽ പാത ഭാഗങ്ങളുടെ ഒരു ക്രമം ഒരു സമ്പൂർണ്ണ പാതയായി പരിഹരിക്കുന്നു.
- `path.basename(path)`: ഒരു പാതയുടെ അവസാന ഭാഗം തിരികെ നൽകുന്നു.
- `path.dirname(path)`: ഒരു പാതയുടെ ഡയറക്ടറി നാമം തിരികെ നൽകുന്നു.
- `path.extname(path)`: പാതയുടെ എക്സ്റ്റൻഷൻ തിരികെ നൽകുന്നു.
`path` മൊഡ്യൂളിനായി ടൈപ്പ്സ്ക്രിപ്റ്റ് പൂർണ്ണമായ ടൈപ്പ് നിർവചനങ്ങൾ നൽകുന്നു, അതിന്റെ ഫംഗ്ഷനുകൾ നിങ്ങൾ ശരിയായി ഉപയോഗിക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നു.
import * as path from 'path';
const dir = 'my_app_data';
const filename = 'config.json';
// ക്രോസ്-പ്ലാറ്റ്ഫോം പാത ചേർക്കൽ
const fullPath: string = path.join(__dirname, dir, filename);
console.log(`ക്രോസ്-പ്ലാറ്റ്ഫോം പാത: ${fullPath}`);
// ഡയറക്ടറി നാമം നേടുക
const dirname: string = path.dirname(fullPath);
console.log(`ഡയറക്ടറി നാമം: ${dirname}`);
// അടിസ്ഥാന ഫയൽ നാമം നേടുക
const basename: string = path.basename(fullPath);
console.log(`അടിസ്ഥാന നാമം: ${basename}`);
// ഫയൽ എക്സ്റ്റൻഷൻ നേടുക
const extname: string = path.extname(fullPath);
console.log(`എക്സ്റ്റൻഷൻ: ${extname}`);
ഒരേസമയം പ്രവർത്തിക്കുന്ന അവസ്ഥയും റേസ് കണ്ടീഷനുകളും
ഒരേ സമയം നിരവധി അസിൻക്രണസ് ഫയൽ പ്രവർത്തനങ്ങൾ ആരംഭിക്കുമ്പോൾ, പ്രത്യേകിച്ചും എഴുത്തുകളോ ഡിലീഷനുകളോ, റേസ് കണ്ടീഷനുകൾ സംഭവിക്കാം. ഉദാഹരണത്തിന്, ഒരു പ്രവർത്തനം ഒരു ഫയലിന്റെ നിലനിൽപ്പ് പരിശോധിക്കുകയും മറ്റൊരു പ്രവർത്തനം ആദ്യത്തെ പ്രവർത്തനം നടക്കുന്നതിന് മുമ്പ് അത് ഡിലീറ്റ് ചെയ്യുകയും ചെയ്താൽ, ആദ്യത്തെ പ്രവർത്തനം അപ്രതീക്ഷിതമായി പരാജയപ്പെട്ടേക്കാം.
- പ്രധാനപ്പെട്ട പാത ലോജിക്കിനായി `fs.existsSync` ഒഴിവാക്കുക; `fs.access` അല്ലെങ്കിൽ പ്രവർത്തനം നേരിട്ട് ശ്രമിക്കുകയും പിശക് കൈകാര്യം ചെയ്യുകയും ചെയ്യുക.
- പ്രത്യേക ആക്സസ് ആവശ്യമുള്ള പ്രവർത്തനങ്ങൾക്ക്, ഉചിതമായ `flag` ഓപ്ഷനുകൾ ഉപയോഗിക്കുക (ഉദാഹരണത്തിന്, exclusive write നായി `'wx'`).
- വളരെ നിർണായകമായ പങ്കിട്ട റിസോഴ്സ് ആക്സസിനായി ലോക്കിംഗ് മെക്കാനിസങ്ങൾ (ഉദാഹരണത്തിന്, ഫയൽ ലോക്കുകൾ, അല്ലെങ്കിൽ ആപ്ലിക്കേഷൻ-ലെവൽ ലോക്കുകൾ) നടപ്പിലാക്കുക, എന്നിരുന്നാലും ഇത് സങ്കീർണ്ണത വർദ്ധിപ്പിക്കുന്നു.
അനുമതികൾ (ACLs)
ഫയൽ സിസ്റ്റം അനുമതികൾ (Access Control Lists അല്ലെങ്കിൽ സ്റ്റാൻഡേർഡ് Unix അനുമതികൾ) പിശകുകളുടെ ഒരു സാധാരണ ഉറവിടമാണ്. നിങ്ങളുടെ Node.js പ്രോസസ്സിന് ഫയലുകളും ഡയറക്ടറികളും വായിക്കാനും എഴുതാനും പ്രവർത്തിപ്പിക്കാനും ആവശ്യമായ അനുമതികൾ ഉണ്ടെന്ന് ഉറപ്പാക്കുക. കണ്ടെയ്‌നറൈസ്ഡ് ചുറ്റുപാടുകളിലോ പ്രത്യേക ഉപയോക്തൃ അക്കൗണ്ടുകളോടെ പ്രോസസ്സുകൾ പ്രവർത്തിക്കുന്ന മൾട്ടി-യൂസർ സിസ്റ്റങ്ങളിലോ ഇത് പ്രത്യേകിച്ചും പ്രസക്തമാണ്.
ഉപസംഹാരം: ആഗോള ഫയൽ സിസ്റ്റം പ്രവർത്തനങ്ങൾക്കായി ടൈപ്പ് സുരക്ഷ സ്വീകരിക്കുക
ഫയൽ സിസ്റ്റവുമായി സംവദിക്കുന്നതിനുള്ള ശക്തവും ബഹുമുഖവുമായ ഒരു ഉപകരണമാണ് Node.js `fs` മൊഡ്യൂൾ, അടിസ്ഥാന ഫയൽ കൃത്രിമങ്ങൾ മുതൽ വിപുലമായ സ്ട്രീം അടിസ്ഥാനമാക്കിയുള്ള ഡാറ്റാ പ്രോസസ്സിംഗ് വരെ നിരവധി ഓപ്ഷനുകൾ ഇത് വാഗ്ദാനം ചെയ്യുന്നു. ഈ പ്രവർത്തനങ്ങൾക്ക് മുകളിൽ ടൈപ്പ്സ്ക്രിപ്റ്റ് ലെയർ ചെയ്യുമ്പോൾ, നിങ്ങൾക്ക് വിലമതിക്കാനാവാത്ത നേട്ടങ്ങൾ ലഭിക്കുന്നു: കംപൈൽ-ടൈം പിശക് കണ്ടെത്തൽ, മെച്ചപ്പെട്ട കോഡ് വ്യക്തത, മികച്ച ടൂളിംഗ് പിന്തുണ, റിഫാക്റ്ററിംഗ് സമയത്ത് വർദ്ധിച്ച വിശ്വാസം. വൈവിധ്യമാർന്ന കോഡ്ബേസുകളിൽ സ്ഥിരതയും അവ്യക്തത കുറയ്ക്കുന്നതും നിർണായകമായ ആഗോള ഡെവലപ്‌മെന്റ് ടീമുകൾക്ക് ഇത് പ്രത്യേകിച്ചും പ്രധാനമാണ്.
നിങ്ങൾ ഒരു ചെറിയ യൂട്ടിലിറ്റി സ്ക്രിപ്റ്റ് നിർമ്മിക്കുകയാണോ അതോ ഒരു വലിയ തോതിലുള്ള എന്റർപ്രൈസ് ആപ്ലിക്കേഷൻ നിർമ്മിക്കുകയാണോ എന്നത് പരിഗണിക്കാതെ, നിങ്ങളുടെ Node.js ഫയൽ പ്രവർത്തനങ്ങൾക്കായി ടൈപ്പ്സ്ക്രിപ്റ്റിന്റെ കരുത്തുറ്റ ടൈപ്പ് സിസ്റ്റം ഉപയോഗിക്കുന്നത് കൂടുതൽ പരിപാലിക്കാൻ കഴിയുന്നതും, വിശ്വസനീയവും, പിശകുകൾ കുറഞ്ഞതുമായ കോഡിലേക്ക് നയിക്കും. വൃത്തിയുള്ള അസിൻക്രണസ് പാറ്റേണുകൾക്കായി `fs/promises` API സ്വീകരിക്കുക, സിൻക്രണസ്, അസിൻക്രണസ് കോളുകൾ തമ്മിലുള്ള സൂക്ഷ്മ വ്യത്യാസങ്ങൾ മനസ്സിലാക്കുക, എല്ലായ്പ്പോഴും കരുത്തുറ്റ പിശക് കൈകാര്യം ചെയ്യലിനും ക്രോസ്-പ്ലാറ്റ്ഫോം പാത മാനേജ്മെന്റിനും മുൻഗണന നൽകുക.
ഈ ഗൈഡിൽ ചർച്ച ചെയ്ത തത്വങ്ങളും ഉദാഹരണങ്ങളും പ്രയോഗിക്കുന്നതിലൂടെ, ലോകമെമ്പാടുമുള്ള ഡെവലപ്പർമാർക്ക് പ്രകടനക്ഷമവും കാര്യക്ഷമവുമായ ഫയൽ സിസ്റ്റം ഇന്ററാക്ഷനുകൾ നിർമ്മിക്കാൻ കഴിയും, അത് അന്തർലീനമായി കൂടുതൽ സുരക്ഷിതവും ചിന്തിക്കാൻ എളുപ്പമുള്ളതുമാണ്, ഇത് ആത്യന്തികമായി ഉയർന്ന നിലവാരമുള്ള സോഫ്റ്റ്‌വെയർ ഡെലിവറികൾക്ക് കാരണമാകുന്നു.